package com.qfedu.config;

import org.apache.ibatis.cache.Cache;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class RedisCache implements Cache {
//id就是我们namespace传递过来
//namespace="com.qfedu.dao.XXXDao"

    private String id;
    //可重入读写锁，有两个锁，读锁，写锁
    //可以多个线程 同时读，只要有一个线程写，其他写都要等待锁释放
    //读写互斥，读读可以共生
private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();

public RedisCache(String id){
    this.id=id;
}

    public String getId() {
        return this.id;
    }

    /**
     * 存数据
     * @param key
     * @param value
     */
    public void putObject(Object key, Object value) {
        //向redis中添加数据，可有效时间
        getRedisTemplate().opsForValue().set(key.toString(),value,30, TimeUnit.MINUTES);

    }

    /**
     * 获取数据key
     * @param key
     * @return
     * 二级缓存读取数据
     */
    public Object getObject(Object key) {
        return getRedisTemplate().opsForValue().get(key.toString());
    }

    /**
     *
     * @param key
     * @return
     * 二级缓存删除数据
     */
    public Object removeObject(Object key) {
        return getRedisTemplate().delete(key.toString());
    }

    /**
     * 清空二级缓存
     * 其实就是清楚namespace下数据
     */
    public void clear() {
        Set<String> keys = getRedisTemplate().keys("*" + id + "*");
        for (String key : keys) {
            getRedisTemplate().delete(key);
        }
    }

    /**
     * 获取缓存数量
     * @return
     */
    public int getSize() {
        Set<String> keys = getRedisTemplate().keys("*" + id + "*");
        return keys.size();
    }


    public ReadWriteLock getReadWriteLock() {
        return readWriteLock;
    }



//    通过容器得到RedisTemplate

    public RedisTemplate getRedisTemplate(){
        RedisTemplate redisTemplate= (RedisTemplate) ApplicationContextHolder.getApplicationContext().getBean("redisTemplate");

        return redisTemplate;
    }




}
